home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gxdht.h < prev    next >
C/C++ Source or Header  |  1997-04-28  |  11KB  |  252 lines
  1. /* Copyright (C) 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gxdht.h */
  20. /* Definition of device halftones */
  21.  
  22. #ifndef gxdht_INCLUDED
  23. #  define gxdht_INCLUDED
  24.  
  25. #include "gsrefct.h"
  26. #include "gxarith.h"        /* for igcd */
  27. #include "gxhttype.h"
  28.  
  29. /*
  30.  * We represent a halftone tile as a rectangular super-cell consisting of
  31.  * multiple copies of a multi-cell whose corners lie on integral
  32.  * coordinates, which in turn is a parallelogram (normally square) array of
  33.  * basic parallelogram (normally square) cells whose corners lie on rational
  34.  * coordinates.
  35.  *
  36.  * Let T be the aspect ratio (ratio of physical pixel height to physical
  37.  * pixel width), which is abs(xx/yy) for portrait devices and abs(yx/xy) for
  38.  * landscape devices.  We characterize the basic cell by four rational
  39.  * numbers U(') = M(')/R(') and V(') = N(')/R(') where R(') is positive, at
  40.  * least one of U and V (and the corresponding one of U' and V') is
  41.  * non-zero, and U' is approximately U/T and V' is approximately V*T; these
  42.  * numbers define the vertices of the basic cell at device space coordinates
  43.  * (0,0), (U,V), (U-V',U'+V), and (-V',U'); then the multi-cell is defined
  44.  * similarly by M(') and N(').  From these definitions, the basic cell has
  45.  * an area of B = U*U' + V*V' = (M*M' + N*N') / R*R' pixels, and the
  46.  * multi-cell has an area of C = B * R*R' = M*M' + N*N' pixels.
  47.  *
  48.  * If the coefficients of the default device transformation matrix are xx,
  49.  * xy, yx, and yy, then U and V are related to the frequency F and the angle
  50.  * A by:
  51.  *    P = 72 / F;
  52.  *    U = P * (xx * cos(A) + yx * sin(A));
  53.  *    V = P * (xy * cos(A) + yy * sin(A)).
  54.  *
  55.  * We can tile the plane with any rectangular super-cell that consists of
  56.  * repetitions of the multi-cell and whose corners coincide with multi-cell
  57.  * coordinates (0,0).  We observe that for any integers i, j such that i*N -
  58.  * j*M' = 0, a multi-cell corner lies on the X axis at W = i*M + j*N';
  59.  * similarly, if i'*M - j'*N' = 0, a corner lies on the Y axis at W' = i'*N
  60.  * + j'*M'.  Then the super-cell occupies Z = W * W' pixels, consisting of Z
  61.  * / C multi-cells or Z / B basic cells.  The trick in all this is to find
  62.  * values of F and A that aren't too far from the requested ones, and that
  63.  * yield a manageably small value for Z.
  64.  *
  65.  * Note that the super-cell only has to be so large because we want to use
  66.  * it directly to tile the plane.  In fact, we can decompose it into W' / D
  67.  * horizontal strips of width W and height D, shifted horizontally with
  68.  * respect to each other by S pixels, where we compute S by finding h and k
  69.  * such that h*N - k*M' = D and then S = h*M + k*N'.  The halftone setup
  70.  * routines only generate a single strip of samples, and let
  71.  * gx_ht_construct_spot_order construct the rest.  If W' is large, we
  72.  * actually keep only one strip, and let the strip_tile_rectangle routines
  73.  * do the shifting at rendering time.
  74.  */
  75. typedef struct gx_ht_cell_params_s {
  76.     /* Defining values.  M * M1 != 0 or N * N1 != 0; R > 0, R1 > 0. */
  77.     /* R and D are short rather than ushort so that we don't get */
  78.     /* unsigned results from arithmetic. */
  79.   short M, N, R;
  80.   short M1, N1, R1;
  81.     /* Derived values. */
  82.   ulong C;
  83.   short D, D1;
  84.   uint W, W1;
  85.   int S;
  86. } gx_ht_cell_params_t;
  87. /* Compute the derived values from the defining values. */
  88. void gx_compute_cell_values(P1(gx_ht_cell_params_t *));
  89.  
  90. /*
  91.  * The whitening order is represented by a pair of arrays.
  92.  * The levels array contains an integer (an index into the bits array)
  93.  * for each distinct halftone level, indicating how many pixels should be
  94.  * whitened for that level; levels[0] = 0, levels[i] <= levels[i+1], and
  95.  * levels[num_levels-1] <= num_bits.
  96.  * The bits array contains an (offset,mask) pair for each pixel in the tile.
  97.  * bits[i].offset is the (properly aligned) byte index of a pixel
  98.  * in the tile; bits[i].mask is the mask to be or'ed into this byte and
  99.  * following ones.  This is arranged so it will work properly on
  100.  * either big- or little-endian machines, and with different mask widths.
  101.  */
  102. /* The mask width must be at least as wide as uint, */
  103. /* and must not be wider than the width implied by align_bitmap_mod. */
  104. typedef uint ht_mask_t;
  105. #define ht_mask_bits (sizeof(ht_mask_t) * 8)
  106. typedef struct gx_ht_bit_s {
  107.     uint offset;
  108.     ht_mask_t mask;
  109. } gx_ht_bit;
  110. /* During sampling, bits[i].mask is used to hold a normalized sample value. */
  111. typedef ht_mask_t ht_sample_t;
  112. /* The following awkward expression avoids integer overflow. */
  113. #define max_ht_sample (ht_sample_t)(((1 << (ht_mask_bits - 2)) - 1) * 2 + 1)
  114.  
  115. /*
  116.  * Define the internal representation of a halftone order.
  117.  * Note that it may include a cached transfer function.
  118.  *
  119.  * Halftone orders exist in two slightly different configurations, strip and
  120.  * complete.  In a complete order, shift = 0 and full_height = height; in a
  121.  * strip order, shift != 0 and full_height is the height of a fully expanded
  122.  * halftone made up of enough shifted strip copies to get back to a zero
  123.  * shift.  In other words, full_height is a cached value, but it is an
  124.  * important one, since it is the modulus used for computing the
  125.  * tile-relative phase.  Requirements:
  126.  *    width > 0, height > 0, multiple > 0
  127.  *    raster >= bitmap_raster(width)
  128.  *    0 <= shift < width
  129.  *    num_bits = width * height
  130.  * For complete orders:
  131.  *    full_height = height
  132.  * For strip orders:
  133.  *    full_height = height * width / gcd(width, shift)
  134.  * Note that during the sampling of a complete spot halftone, these
  135.  * invariants may be violated; in particular, it is possible that shift != 0
  136.  * and height < full_height, even though num_bits and num_levels reflect the
  137.  * full height.  In this case, the invariant is restored (by resetting
  138.  * shift and height) when sampling is finished.  However, we must save the
  139.  * original height and shift values used for sampling, since sometimes we
  140.  * run the "finishing" routines more than once.  (This is ugly, but it's
  141.  * too hard to fix.)
  142.  *
  143.  * See gxbitmap.h for more details about strip halftones.
  144.  */
  145. typedef struct gx_ht_cache_s gx_ht_cache;
  146. typedef struct gx_ht_order_s {
  147.     gx_ht_cell_params_t params;    /* parameters defining the cells */
  148.     ushort width;
  149.     ushort height;
  150.     ushort raster;
  151.     ushort shift;
  152.     ushort orig_height;
  153.     ushort orig_shift;
  154.     uint full_height;
  155.     uint num_levels;        /* = levels size */
  156.     uint num_bits;            /* = bits size = width * height */
  157.     uint *levels;
  158.     gx_ht_bit *bits;
  159.     gx_ht_cache *cache;        /* cache to use */
  160.     gx_transfer_map *transfer;    /* TransferFunction or 0 */
  161. } gx_ht_order;
  162. #define ht_order_is_complete(porder)\
  163.   ((porder)->shift == 0)
  164. #define ht_order_full_height(porder)\
  165.   ((porder)->shift == 0 ? (porder)->height :\
  166.    (porder)->width / igcd((porder)->width, (porder)->shift) *\
  167.      (porder)->height)
  168.  
  169. /* We only export st_ht_order for use in st_screen_enum. */
  170. extern_st(st_ht_order);
  171. #define public_st_ht_order()    /* in gsht.c */\
  172.   gs_public_st_ptrs4(st_ht_order, gx_ht_order, "gx_ht_order",\
  173.     ht_order_enum_ptrs, ht_order_reloc_ptrs, levels, bits, cache, transfer)
  174. #define st_ht_order_max_ptrs 4
  175.  
  176. /*
  177.  * Define a device halftone.  This consists of one or more orders.
  178.  * If components = 0, then order is the only current halftone screen
  179.  * (set by setscreen, Type 1 sethalftone, Type 3 sethalftone, or
  180.  * Type 5 sethalftone with only a Default).  Otherwise, order is the
  181.  * gray or black screen (for gray/RGB or CMYK devices respectively),
  182.  * and components is an array of gx_ht_order_components parallel to
  183.  * the components of the client halftone (set by setcolorscreen or
  184.  * Type 5 sethalftone).
  185.  *
  186.  * Multi-component halftone orders may be required even in Level 1 systems,
  187.  * because they are needed for setcolorscreen.
  188.  *
  189.  * NOTE: it is assumed that all subsidiary structures of device halftones
  190.  * (the components array, and the bits, levels, cache, and transfer members
  191.  * of any gx_ht_orders, both the default order and any component orders) are
  192.  * allocated with the same allocator as the device halftone itself.
  193.  */
  194. typedef struct gx_ht_order_component_s {
  195.     gx_ht_order corder;
  196.     gs_ht_separation_name cname;
  197. } gx_ht_order_component;
  198. #define private_st_ht_order_component()    /* in gsht.c */\
  199.   gs_private_st_ptrs_add0(st_ht_order_component, gx_ht_order_component,\
  200.     "gx_ht_order_component", ht_order_component_enum_ptrs,\
  201.      ht_order_component_reloc_ptrs, st_ht_order, corder)
  202. #define st_ht_order_component_max_ptrs st_ht_order_max_ptrs
  203. /* We only export st_ht_order_component_element for use in banding. */
  204. extern_st(st_ht_order_component_element);
  205. #define public_st_ht_order_comp_element() /* in gsht.c */\
  206.   gs_public_st_element(st_ht_order_component_element, gx_ht_order_component,\
  207.     "gx_ht_order_component[]", ht_order_element_enum_ptrs,\
  208.     ht_order_element_reloc_ptrs, st_ht_order_component)
  209.  
  210. #ifndef gx_device_halftone_DEFINED
  211. #  define gx_device_halftone_DEFINED
  212. typedef struct gx_device_halftone_s gx_device_halftone;
  213. #endif
  214.  
  215. /*
  216.  * color_indices is a cache that gives the indices in components of
  217.  * the screens for the 1, 3, or 4 primary color(s).  These indices are
  218.  * always in the same order, namely:
  219.  *    -,-,-,W(gray)
  220.  *    R,G,B,-
  221.  *    C,M,Y,K
  222.  */
  223. struct gx_device_halftone_s {
  224.     gx_ht_order order;        /* must be first, for subclassing */
  225.     rc_header rc;
  226.     gs_id id;        /* the id changes whenever the data change */
  227. #ifdef FUTURE
  228.     /* We have to keep the halftone type so that we can pass it */
  229.     /* through the band list for gx_imager_dev_ht_install. */
  230.     gs_halftone_type type;
  231. #endif
  232.     gx_ht_order_component *components;
  233.     uint num_comp;
  234.         /* The following are computed from the above. */
  235.     uint color_indices[4];
  236.     int lcm_width, lcm_height;    /* LCM of primary color tile sizes, */
  237.                     /* max_int if overflowed */
  238. };
  239. extern_st(st_device_halftone);
  240. #define public_st_device_halftone() /* in gsht.c */\
  241.   gs_public_st_ptrs_add1(st_device_halftone, gx_device_halftone,\
  242.     "gx_device_halftone", device_halftone_enum_ptrs,\
  243.     device_halftone_reloc_ptrs, st_ht_order, order, components)
  244. #define st_device_halftone_max_ptrs (st_ht_order_max_ptrs + 1)
  245.  
  246. /* Release a gx_device_halftone by freeing its components. */
  247. /* (Don't free the gx_device_halftone itself.) */
  248. void gx_device_halftone_release(P2(gx_device_halftone *pdht,
  249.                    gs_memory_t *mem));
  250.  
  251. #endif                    /* gxdht_INCLUDED */
  252.